﻿using System;
using System.Linq;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Diagnostics;
//Librerias Arquitectura
using Com.Binaria.Core;
using Com.Binaria.Core.Base;
using Com.Binaria.Core.Dto;
using Com.Binaria.Core.Util;
using Com.Binaria.Core.Datos;
using Com.Binaria.Core.Exceptions;
using Com.Binaria.Core.Enumeracion;
//Librerias Proyecto
using Com.Binaria.SISCOB.Funcional.DTO;
using Com.Binaria.SISCOB.DTO;
using Com.Binaria.SISCOB.DAO;

namespace Com.Binaria.SISCOB.Dom
{
/// <summary>
///	clase de cartola dom
/// </summary>
public partial class DocumentoTransaccionDom : IDocumentoTransaccionDom
{
	#region metodos publicos

    public IRegistroContableDom iRegistroContableDom;
    public IRegistroDocumentoDom iRegistroDocumentoDom;
    public IEgresoDom iEgresoDom;
    public IIngresoDom iIngresoDom;
	

    /// <summary>
    /// metodo que permite registrar elementos de tipo cartola en el sistema
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_Cartola">cartola a registrar (insertar, actualizar o eliminar)</param>
    /// <param name="p_Accion">Accion a realizar</param>
    //public bool Conciliar(ContextoDTO p_Contexto, List<DocumentoTransaccionDTO> docsTrans)
    //{
    //    //Prefijo del Metodo
    //    const String MPREFIX = " [Conciliar]";
    //    //Resultado accion insertar
    //    List<RegistroContableDTO> listRegContableResultDTO = null;
    //    List<RegistroDocumentoDTO> rd = null;
    //    RegistroContableDTO regCont = null;
    //    RegistroContableDTO regC = null;
    //    long tot = 0;
    //    bool result = false;

    //    try
    //    {
    //        //Registro log de inicio del proceso
    //        Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);

    //        //Valida que exista informacion en el objeto
    //        AssertNull.notNullOrEmpty(docsTrans);

    //        foreach (DocumentoTransaccionDTO docT in docsTrans)
    //        {
    //            tot = 0;
    //            //Se realiza la busqueda de los registros contables solo si el documento transaccion esta Activo
    //            if (docT.EstaActivo.Value)
    //            {
    //                if (docT.IdEgreso != null)
    //                {
    //                    if (docT.Egreso == null) docT.Egreso = iEgresoDom.BuscarEgresoPorId(p_Contexto, docT.IdEgreso);
    //                    // Solo se concilian documentos provenientes de cartola del banco o modificaciones del usuario
    //                    if (!"GI:PA".Contains(docT.Egreso.Estado))
    //                    {
    //                        regCont = new RegistroContableDTO();
    //                        regCont.NmrDcto = docT.NmrDocumento;
    //                        regCont.EstaProcesado = false;
    //                        regCont.CartolaMayor = new CartolaMayorDTO() { IdCuentaCorriente = docT.IdCuentaCorriente };

    //                        listRegContableResultDTO = iRegistroContableDom.BuscarRegistroContableByEgreso(p_Contexto, regCont);
    //                        listRegContableResultDTO.ForEach(r => tot += (long)r.Monto);

    //                        //Si el monto del dcto.egreso es igual, se registra la conciliación
    //                        if (docT.Monto == tot)
    //                        {
    //                            rd = new List<RegistroDocumentoDTO>();
    //                            foreach (RegistroContableDTO rc in listRegContableResultDTO)
    //                            {
    //                                rd.Add(new RegistroDocumentoDTO() { IdDocumentoTransaccion = docT.Id, IdRegistroContable = rc.Id });
    //                                // Una vez conciliado se marca como procesado el registro contable
    //                                rc.EstaProcesado = true;
    //                            }
    //                            rd = iRegistroDocumentoDom.RegistrarRegistroDocumento(p_Contexto, rd, EnumRegistrarAccion.Agregar);
    //                            listRegContableResultDTO = iRegistroContableDom.RegistrarRegistroContable(p_Contexto, listRegContableResultDTO, EnumRegistrarAccion.Modificar);
    //                            docT.Egreso.Estado = "PA";
    //                            iEgresoDom.RegistrarEgreso(p_Contexto, new List<EgresoDTO>() { docT.Egreso }, EnumRegistrarAccion.Modificar);
    //                            result = true;
    //                        }

    //                        //Si el monto del dcto.egreso NO es igual, se registra el egreso como observado
    //                        if (docT.Monto != tot)
    //                        {
    //                            if (tot > 0)
    //                            {
    //                                docT.Egreso.Estado = "OI"; // Observado Inconsistente
    //                            }
    //                            if (tot == 0)
    //                            {
    //                                docT.Egreso.Estado = "ON"; // Observado No Contabilizado
    //                            }
    //                            iEgresoDom.RegistrarEgreso(p_Contexto, new List<EgresoDTO>() { docT.Egreso }, EnumRegistrarAccion.Modificar);
    //                        }
    //                    }
    //                }
    //                if (docT.IdIngreso != null)
    //                {
    //                    if (docT.Ingreso == null) docT.Ingreso = iIngresoDom.BuscarIngresoPorId(p_Contexto, docT.IdIngreso);
    //                    // Solo se concilian documentos provenientes de cartola del banco o modificaciones del usuario
    //                    if (!"RE:CO".Contains(docT.Ingreso.Estado))
    //                    {
    //                        regCont = new RegistroContableDTO();
    //                        regCont.Monto = docT.Monto;
    //                        regCont.FchRegistro = docT.FchDocumento;

    //                        // Una vez conciliado se marca como procesado el registro contable
    //                        regCont.EstaProcesado = false;
    //                        regCont.CartolaMayor = new CartolaMayorDTO() { IdCuentaCorriente = docT.IdCuentaCorriente };

    //                        listRegContableResultDTO = iRegistroContableDom.BuscarRegistroContableByIngreso(p_Contexto, regCont);

    //                        List<RegistroContableDTO> listRegC = listRegContableResultDTO.Where(obj => obj.FchRegistro.Equals(docT.FchDocumento)).ToList();
    //                        regC = (listRegC.Count > 0 ? listRegC[0] : null);
    //                        //Si existe un registro contable para el Ingreso, se registra el Ingreso como Contabilizado
    //                        if (listRegContableResultDTO.Count > 0)
    //                        {
    //                            rd = new List<RegistroDocumentoDTO>();

    //                            regC = (regC != null ? regC : listRegContableResultDTO[0]);
    //                            rd.Add(new RegistroDocumentoDTO() { IdDocumentoTransaccion = docT.Id, IdRegistroContable = regC.Id });
    //                            // Una vez conciliado se marca como procesado el registro contable
    //                            regC.EstaProcesado = true;
    //                            rd = iRegistroDocumentoDom.RegistrarRegistroDocumento(p_Contexto, rd, EnumRegistrarAccion.Agregar);
    //                            iRegistroContableDom.RegistrarRegistroContable(p_Contexto, listRegContableResultDTO, EnumRegistrarAccion.Modificar);
    //                            docT.Ingreso.Estado = "CO";
    //                            iIngresoDom.RegistrarIngreso(p_Contexto, new List<IngresoDTO>() { docT.Ingreso }, EnumRegistrarAccion.Modificar);
    //                            result = true;
    //                        }

    //                        //Si NO existe un registro contable para el Ingreso, se registra el Ingreso como observado (No Contabilizado)
    //                        if (listRegContableResultDTO.Count == 0)
    //                        {

    //                            docT.Ingreso.Estado = "OB";
    //                            iIngresoDom.RegistrarIngreso(p_Contexto, new List<IngresoDTO>() { docT.Ingreso }, EnumRegistrarAccion.Modificar);
    //                        }
    //                    }
    //                }
    //            }
    //        }

    //        //Registro log de ejecucion el termino del metodo
    //        Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
    //    }
    //    catch (ManagerException me)
    //    {
    //        throw (me);
    //    }
    //    catch (ArquitecturaException ae)
    //    {
    //        throw (ae);
    //    }
    //    catch (Exception ex)
    //    {
    //        //Registro log de ejecucion con problemas
    //        Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
    //        //Genero error
    //        throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
    //    }
    //    return result;
    //}


    /// <summary>
    /// metodo que permite registrar elementos de tipo cartola en el sistema
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_Cartola">cartola a registrar (insertar, actualizar o eliminar)</param>
    /// <param name="p_Accion">Accion a realizar</param>
    public bool Conciliar(ContextoDTO p_Contexto, List<DocumentoTransaccionDTO> docsTrans)
    {
        //Prefijo del Metodo
        const String MPREFIX = " [Conciliar]";
        //Resultado accion insertar
        List<DocumentoTransaccionDTO> listDocTransResultDTO = null;
        DocumentoTransaccionDTO filtroDocTransDTO = null;
        long tot = 0;
        bool result = false;
        int idCtaCte = 0;

        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);

            //Valida que exista informacion en el objeto
            AssertNull.notNullOrEmpty(docsTrans);

            foreach (DocumentoTransaccionDTO docT in docsTrans)
            {
                tot = 0;
                //Se realiza la busqueda de los registros contables solo si el documento transaccion esta Activo
                if (docT.EstaActivo.Value)
                {
                    idCtaCte = docT.IdCuentaCorriente.Value;
                    if (docT.IdEgreso != null)
                    {
                        if (docT.Egreso == null) docT.Egreso = iEgresoDom.BuscarEgresoPorId(p_Contexto, docT.IdEgreso);
                        // Solo se concilian documentos provenientes de cartola del banco o modificaciones del usuario
                        if (!"PA:CA".Contains(docT.Egreso.Estado))
                        {
                            filtroDocTransDTO = new DocumentoTransaccionDTO();
                            filtroDocTransDTO.IdCuentaCorriente = docT.IdCuentaCorriente;
                            filtroDocTransDTO.NmrDocumento = docT.NmrDocumento;
                            filtroDocTransDTO.EstaActivo = true;

                            listDocTransResultDTO = this.BuscarDocumentoTransaccionFiltro(p_Contexto, filtroDocTransDTO);
                            listDocTransResultDTO.ForEach(r => tot += (long)r.Monto);

                            //Si el monto del dcto.egreso es igual, se registra la conciliación
                            if (docT.Monto == tot)
                            {
                                docT.Egreso.Estado = "PA";
                                iEgresoDom.RegistrarEgreso(p_Contexto, new List<EgresoDTO>() { docT.Egreso }, EnumRegistrarAccion.Modificar);
                                result = true;
                            }

                            //Si el monto del dcto.egreso NO es igual, se registra el egreso como observado
                            if (docT.Monto != tot)
                            {
                                if (tot > 0)
                                {
                                    docT.Egreso.Estado = "OI"; // Observado Inconsistente
                                }
                                if (tot == 0)
                                {
                                    docT.Egreso.Estado = "ON"; // Observado No Contabilizado
                                }
                                iEgresoDom.RegistrarEgreso(p_Contexto, new List<EgresoDTO>() { docT.Egreso }, EnumRegistrarAccion.Modificar);
                            }
                        }
                    }
                    if (docT.IdIngreso != null)
                    {
                        if (docT.Ingreso == null) docT.Ingreso = iIngresoDom.BuscarIngresoPorId(p_Contexto, docT.IdIngreso);
                        // Solo se concilian documentos provenientes de cartola del banco o modificaciones del usuario
                        if (!"CO".Contains(docT.Ingreso.Estado))
                        {

                            filtroDocTransDTO = new DocumentoTransaccionDTO();
                            filtroDocTransDTO.IdCuentaCorriente = docT.IdCuentaCorriente;
                            filtroDocTransDTO.Monto = docT.Monto;
                            //filtroDocTransDTO.FchDocumento = docT.FchDocumento;
                            filtroDocTransDTO.EstaActivo = true;

                            listDocTransResultDTO = this.BuscarDocumentoTransaccionFiltro(p_Contexto, filtroDocTransDTO);

                            //Si existe un registro contable para el Ingreso, se registra el Ingreso como Contabilizado
                            if (listDocTransResultDTO.Count > 0)
                            {
                                docT.Ingreso.Estado = "CO";
                                iIngresoDom.RegistrarIngreso(p_Contexto, new List<IngresoDTO>() { docT.Ingreso }, EnumRegistrarAccion.Modificar);
                                result = true;
                            }

                            //Si NO existe un registro contable para el Ingreso, se registra el Ingreso como observado (No Contabilizado)
                            if (listDocTransResultDTO.Count == 0)
                            {

                                docT.Ingreso.Estado = "OB";
                                iIngresoDom.RegistrarIngreso(p_Contexto, new List<IngresoDTO>() { docT.Ingreso }, EnumRegistrarAccion.Modificar);
                            }
                        }
                    }

                }
            }

            // Se realiza la conciliacion cruzada entre los ingresos no abonados y los cheque no cobrados
            ConciliarCruzada(p_Contexto,idCtaCte);

            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (ManagerException me)
        {
            throw (me);
        }
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return result;
    }


    /// <summary>
    /// Metodo que permite buscar los elementos de tipo documentotransaccion existentes
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_Filtro">informacion de filtrado para realizar la busqueda</param>
    /// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>	
    public List<DocumentoTransaccionDTO> BuscarIngresoObservado(ContextoDTO p_Contexto, ConciliacionDTO p_ConcDTO)
    {
        //Prefijo del Metodo
        const string MPREFIX = " [BuscarIngresoObservado(ContextoDTO p_Contexto, ConciliacionDTO p_ConcDTO)]";
        //Crea lista de objetos de salida
        List<DocumentoTransaccionDTO> RespuestaBuscar = new List<DocumentoTransaccionDTO>();

        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);

            //Valida que exista informacion a insertar
            AssertNull.notNullOrEmpty(p_ConcDTO);

            //Obtengo la lista de objetos almacenados en la base de datos
            RespuestaBuscar = iDocumentoTransaccionDAO.BuscarIngresoObservado(p_ConcDTO); ;

            //Registro log de termino OK del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (ManagerException me)
        {
            throw (me);
        }
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
    }

    /// <summary>
    /// Metodo que permite buscar los elementos de tipo documentotransaccion existentes
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_Filtro">informacion de filtrado para realizar la busqueda</param>
    /// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>	
    public List<DocumentoTransaccionDTO> BuscarEgresoObservado(ContextoDTO p_Contexto, ConciliacionDTO p_ConcDTO)
    {
        //Prefijo del Metodo
        const string MPREFIX = " [BuscarEgresoObservado(ContextoDTO p_Contexto, ConciliacionDTO p_ConcDTO)]";
        //Crea lista de objetos de salida
        List<DocumentoTransaccionDTO> RespuestaBuscar = new List<DocumentoTransaccionDTO>();

        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);

            //Valida que exista informacion a insertar
            AssertNull.notNullOrEmpty(p_ConcDTO);

            //Obtengo la lista de objetos almacenados en la base de datos
            RespuestaBuscar = iDocumentoTransaccionDAO.BuscarEgresoObservado(p_ConcDTO); ;

            //Registro log de termino OK del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (ManagerException me)
        {
            throw (me);
        }
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
    }


    /// <summary>
    /// Metodo que permite buscar los elementos de tipo documentotransaccion existentes
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_Filtro">informacion de filtrado para realizar la busqueda</param>
    /// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>	
    public List<DocumentoTransaccionDTO> BuscarByEgreso(ContextoDTO p_Contexto, DocumentoTransaccionDTO dtoin)
    {
        //Prefijo del Metodo
        const string MPREFIX = " [BuscarByEgreso(ContextoDTO p_Contexto, DocumentoTransaccionDTO dtoin)]";
        //Crea lista de objetos de salida
        List<DocumentoTransaccionDTO> RespuestaBuscar = new List<DocumentoTransaccionDTO>();

        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);

            //Valida que exista informacion a insertar
            AssertNull.notNullOrEmpty(dtoin);

            //Obtengo la lista de objetos almacenados en la base de datos
            RespuestaBuscar = iDocumentoTransaccionDAO.FindByEgreso(dtoin); ;

            //Registro log de termino OK del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (ManagerException me)
        {
            throw (me);
        }
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
    }


    /// <summary>
    /// Metodo que permite buscar los elementos de tipo documentotransaccion existentes
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_Filtro">informacion de filtrado para realizar la busqueda</param>
    /// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>	
    public List<DocumentoTransaccionDTO> BuscarByIngreso(ContextoDTO p_Contexto, DocumentoTransaccionDTO dtoin)
    {
        //Prefijo del Metodo
        const string MPREFIX = " [BuscarByIngreso(ContextoDTO p_Contexto, DocumentoTransaccionDTO dtoin)]";
        //Crea lista de objetos de salida
        List<DocumentoTransaccionDTO> RespuestaBuscar = new List<DocumentoTransaccionDTO>();

        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);

            //Valida que exista informacion a insertar
            AssertNull.notNullOrEmpty(dtoin);

            //Obtengo la lista de objetos almacenados en la base de datos
            RespuestaBuscar = iDocumentoTransaccionDAO.FindByIngreso(dtoin); ;

            //Registro log de termino OK del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (ManagerException me)
        {
            throw (me);
        }
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
    }


    /// <summary>
    /// Metodo que permite buscar los elementos de tipo documentotransaccion existentes
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_Filtro">informacion de filtrado para realizar la busqueda</param>
    /// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>	
    public List<DocumentoTransaccionDTO> BuscarByIngresoNoAbonado(ContextoDTO p_Contexto, DocumentoTransaccionDTO dtoin)
    {
        //Prefijo del Metodo
        const string MPREFIX = " [BuscarByIngresoNoAbonado(ContextoDTO p_Contexto, DocumentoTransaccionDTO dtoin)";
        //Crea lista de objetos de salida
        List<DocumentoTransaccionDTO> RespuestaBuscar = new List<DocumentoTransaccionDTO>();

        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);

            //Valida que exista informacion a insertar
            AssertNull.notNullOrEmpty(dtoin);

            //Obtengo la lista de objetos almacenados en la base de datos
            RespuestaBuscar = iDocumentoTransaccionDAO.FindByIngresoNoAbonado(dtoin); ;

            //Registro log de termino OK del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (ManagerException me)
        {
            throw (me);
        }
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
    }


    /// <summary>
    /// metodo que permite registrar elementos de tipo cartola en el sistema
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_Cartola">cartola a registrar (insertar, actualizar o eliminar)</param>
    /// <param name="p_Accion">Accion a realizar</param>
    public bool ConciliarCruzada(ContextoDTO p_Contexto, int idCtaCte)
    {
        //Prefijo del Metodo
        const String MPREFIX = " [ConciliarCruzada(ContextoDTO p_Contexto, int idCtaCte)]";
        //Resultado accion insertar
        List<DocumentoTransaccionDTO> listDocTransIngresosNoAbonadosDTO = null;
        List<DocumentoTransaccionDTO> listDocTransEgresosNoCobradosDTO = null;
        DocumentoTransaccionDTO filtroDocTransDTO = null;
        long tot = 0;
        bool result = false;

        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);

            //Valida que exista informacion en el objeto
            AssertNull.notNullOrEmpty(idCtaCte);

            // Se buscan todos los Ingresos No Abonados
            listDocTransIngresosNoAbonadosDTO = iDocumentoTransaccionDAO.FindByIngresoNoAbonado(new DocumentoTransaccionDTO() {IdCuentaCorriente = idCtaCte });

            foreach (DocumentoTransaccionDTO dtRE in listDocTransIngresosNoAbonadosDTO)
            {
                tot = 0;
                // Por cada Ingreso No Abonado se buscan los Egresos No Cobrados
                dtRE.NmrDocumento = Convert.ToInt32(dtRE.NmrDocumento).ToString();
                listDocTransEgresosNoCobradosDTO = iDocumentoTransaccionDAO.FindByEgreso(dtRE);
                listDocTransEgresosNoCobradosDTO.ForEach(dt => tot += dt.Monto.Value);
                if (tot == dtRE.Monto.Value)
                {
                    foreach (DocumentoTransaccionDTO dtGI in listDocTransEgresosNoCobradosDTO)
                    {
                        EgresoDTO egresoDTO = iEgresoDom.BuscarEgresoPorId(p_Contexto, dtGI.IdEgreso);
                        egresoDTO.Estado = "CA";
                        iEgresoDom.RegistrarEgreso(p_Contexto, new List<EgresoDTO>() { egresoDTO }, EnumRegistrarAccion.Modificar);
                    }
                    dtRE.EstaActivo = false;
                    iDocumentoTransaccionDAO.Update(new DocumentoTransaccionDTO[1] { dtRE });
                }
            }

            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (ManagerException me)
        {
            throw (me);
        }
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return result;
    }


    #endregion metodos publicos

	}//End class CartolaDom
}//End namespace





